PolyOsManager

import android.content.Context
import com.poly.polyos.AppState
import com.poly.polyos.PolyOsManager
import com.poly.polyos.audio.IPolyAudioListener
import com.poly.polyos.room.IPolyRoomListener
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
fun main() { 
   //sampleStart 
   /**
 * Sample usages for [PolyOsManager]
 */
class PolyOsSample {


    /**
     * Sample usage of [PolyOsManager]
     */
    suspend fun samplePolyOsManagerCreation(context: Context) {

        //Create PolyOsManager using context.
        val polyOsManager = PolyOsManager(context)

        //@see sampleNotifyOnAppStateChange of how to notify of app state changes
    }

    /**
     * Sample usage of how to listen for connection state changes
     */
    suspend fun samplePolyOsManagerConnectionStateListen(context: Context, scope: CoroutineScope) {

        //Create PolyOsManager using context.
        val polyOsManager = PolyOsManager(context)

        println("Connected ${polyOsManager.connectedState.value}")

        scope.launch {
            polyOsManager.connectedState.collect { connected ->
                println("Connected $connected")
            }
        }
    }

    /**
     * Notify polyos on app state changes like in call, content etc
     */
    suspend fun sampleNotifyOnAppStateChange(polyOsManager: PolyOsManager) {
        val currentAppState = AppState()

        //When in call, notify polyOs
        currentAppState.inCall = true
        polyOsManager.notifyAppStateChanged(currentAppState)

        //When out of  call, notify polyOs
        currentAppState.inCall = false
        polyOsManager.notifyAppStateChanged(currentAppState)
    }

    /**
     * Sample polyos api call using helper function that suspends until connected
     */
    suspend fun sampleAudioApi(polyOsManager: PolyOsManager) {
        //get mute state
        //call through suspend helper. suspends until connected with service
        val isMuted = polyOsManager { audioService.isMicrophoneMuted }

        //Mute audio
        polyOsManager { audioService.muteMicrophone(true) }
    }

    /**
     * Sample polyos api call using helper function that suspends until connected
     */
    fun sampleRunWhenConnected(polyOsManager: PolyOsManager, audioListener: IPolyAudioListener, roomListener: IPolyRoomListener) {

        //register listeners whenever polyos gets connected/reconnected
        polyOsManager.runWhenConnected {

            //Register for audio notifications
            audioService.registerAudioListener(audioListener)

            //Register for messages
            roomService.registerRoomListener(roomListener)
        }

        //Perform a one time task on first connection
        polyOsManager.runWhenConnected (oneshot = true) {
            val muted = audioService.isMicrophoneMuted
            println( "Audio is muted: $muted")
        }

    }
} 
   //sampleEnd
}